{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"figures/PDSH-cover-small.png\">\n",
    "\n",
    "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
    "\n",
    "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Simple Scatter Plots](04.02-Simple-Scatter-Plots.ipynb) | [Contents](Index.ipynb) | [Density and Contour Plots](04.04-Density-and-Contour-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/04.03-Errorbars.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing Errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For any scientific measurement, accurate accounting for errors is nearly as important, if not more important, than accurate reporting of the number itself.\n",
    "For example, imagine that I am using some astrophysical observations to estimate the Hubble Constant, the local measurement of the expansion rate of the Universe.\n",
    "I know that the current literature suggests a value of around 71 (km/s)/Mpc, and I measure a value of 74 (km/s)/Mpc with my method. Are the values consistent? The only correct answer, given this information, is this: there is no way to know.\n",
    "\n",
    "Suppose I augment this information with reported uncertainties: the current literature suggests a value of around 71 $\\pm$ 2.5 (km/s)/Mpc, and my method has measured a value of 74 $\\pm$ 5 (km/s)/Mpc. Now are the values consistent? That is a question that can be quantitatively answered.\n",
    "\n",
    "In visualization of data and results, showing these errors effectively can make a plot convey much more complete information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Errorbars\n",
    "\n",
    "A basic errorbar can be created with a single Matplotlib function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 50)\n",
    "dy = 0.8\n",
    "y = np.sin(x) + dy * np.random.randn(50)\n",
    "\n",
    "plt.errorbar(x, y, yerr=dy, fmt='.k');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the ``fmt`` is a format code controlling the appearance of lines and points, and has the same syntax as the shorthand used in ``plt.plot``, outlined in [Simple Line Plots](04.01-Simple-Line-Plots.ipynb) and [Simple Scatter Plots](04.02-Simple-Scatter-Plots.ipynb).\n",
    "\n",
    "In addition to these basic options, the ``errorbar`` function has many options to fine-tune the outputs.\n",
    "Using these additional options you can easily customize the aesthetics of your errorbar plot.\n",
    "I often find it helpful, especially in crowded plots, to make the errorbars lighter than the points themselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.errorbar(x, y, yerr=dy, fmt='o', color='black',\n",
    "             ecolor='lightgray', elinewidth=3, capsize=0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to these options, you can also specify horizontal errorbars (``xerr``), one-sided errorbars, and many other variants.\n",
    "For more information on the options available, refer to the docstring of ``plt.errorbar``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuous Errors\n",
    "\n",
    "In some situations it is desirable to show errorbars on continuous quantities.\n",
    "Though Matplotlib does not have a built-in convenience routine for this type of application, it's relatively easy to combine primitives like ``plt.plot`` and ``plt.fill_between`` for a useful result.\n",
    "\n",
    "Here we'll perform a simple *Gaussian process regression*, using the Scikit-Learn API (see [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) for details).\n",
    "This is a method of fitting a very flexible non-parametric function to data with a continuous measure of the uncertainty.\n",
    "We won't delve into the details of Gaussian process regression at this point, but will focus instead on how you might visualize such a continuous error measurement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name 'GaussianProcess' from 'sklearn.gaussian_process' (C:\\Users\\KZCF\\Anaconda3\\lib\\site-packages\\sklearn\\gaussian_process\\__init__.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-0aeb76e3f6ca>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgaussian_process\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mGaussianProcess\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m# define the model and draw some data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mmodel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mxdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mImportError\u001b[0m: cannot import name 'GaussianProcess' from 'sklearn.gaussian_process' (C:\\Users\\KZCF\\Anaconda3\\lib\\site-packages\\sklearn\\gaussian_process\\__init__.py)"
     ]
    }
   ],
   "source": [
    "#from sklearn.gaussian_process import GaussianProcess\n",
    "#\n",
    "## define the model and draw some data\n",
    "#model = lambda x: x * np.sin(x)\n",
    "#xdata = np.array([1, 3, 5, 6, 8])\n",
    "#ydata = model(xdata)\n",
    "#\n",
    "## Compute the Gaussian process fit\n",
    "#gp = GaussianProcess(corr='cubic', theta0=1e-2, thetaL=1e-4, thetaU=1E-1,\n",
    "#                     random_start=100)\n",
    "#gp.fit(xdata[:, np.newaxis], ydata)\n",
    "#\n",
    "#xfit = np.linspace(0, 10, 1000)\n",
    "#yfit, MSE = gp.predict(xfit[:, np.newaxis], eval_MSE=True)\n",
    "#dyfit = 2 * np.sqrt(MSE)  # 2*sigma ~ 95% confidence region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import RBF, ConstantKernel\n",
    "\n",
    "# define the model and draw some data\n",
    "model = lambda x: x * np.sin(x)\n",
    "xdata = np.array([1, 3, 5, 6, 8])\n",
    "ydata = model(xdata)\n",
    "\n",
    "\n",
    "kernel = ConstantKernel(0.1, (0.001,0.1))*RBF(0.5,(1e-4,10))\n",
    "\n",
    "# Compute the Gaussian process fit\n",
    "#gp = GaussianProcessRegressor(corr='cubic', theta0=1e-2, thetaL=1e-4, thetaU=1E-1,random_start=100)\n",
    "\n",
    "gp = GaussianProcessRegressor(kernel=kernel,n_restarts_optimizer=10,alpha=0.1)\n",
    "gp.fit(xdata[:, np.newaxis], ydata)\n",
    "\n",
    "xfit = np.linspace(0, 10, 1000)\n",
    "#yfit, MSE = gp.predict(xfit[:, np.newaxis], eval_MSE=True)\n",
    "yfit, MSE = gp.predict(xfit[:, np.newaxis],return_std=True)\n",
    "dyfit = 2 * np.sqrt(MSE)  # 2*sigma ~ 95% confidence region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have ``xfit``, ``yfit``, and ``dyfit``, which sample the continuous fit to our data.\n",
    "We could pass these to the ``plt.errorbar`` function as above, but we don't really want to plot 1,000 points with 1,000 errorbars.\n",
    "Instead, we can use the ``plt.fill_between`` function with a light color to visualize this continuous error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the result\n",
    "plt.plot(xdata, ydata, 'or')\n",
    "plt.plot(xfit, yfit, '-', color='gray')\n",
    "\n",
    "plt.fill_between(xfit, yfit - dyfit, yfit + dyfit,\n",
    "                 color='gray', alpha=0.2)\n",
    "plt.xlim(0, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note what we've done here with the ``fill_between`` function: we pass an x value, then the lower y-bound, then the upper y-bound, and the result is that the area between these regions is filled.\n",
    "\n",
    "The resulting figure gives a very intuitive view into what the Gaussian process regression algorithm is doing: in regions near a measured data point, the model is strongly constrained and this is reflected in the small model errors.\n",
    "In regions far from a measured data point, the model is not strongly constrained, and the model errors increase.\n",
    "\n",
    "For more information on the options available in ``plt.fill_between()`` (and the closely related ``plt.fill()`` function), see the function docstring or the Matplotlib documentation.\n",
    "\n",
    "Finally, if this seems a bit too low level for your taste, refer to [Visualization With Seaborn](04.14-Visualization-With-Seaborn.ipynb), where we discuss the Seaborn package, which has a more streamlined API for visualizing this type of continuous errorbar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Simple Scatter Plots](04.02-Simple-Scatter-Plots.ipynb) | [Contents](Index.ipynb) | [Density and Contour Plots](04.04-Density-and-Contour-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/04.03-Errorbars.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
